{***************************************************************
    SpyGestion  Copyright (C) 2008 Christophe KOALI <nature2gas@gmail.com>
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
****************************************************************}
unit modAttackAuto;

interface

uses modFlotteVaisseauxChoix, modBaseDeDonnesRapport,
     modBaseType,
     modClasses,
     modPlanete,
     sFonctionsChaines,
     modRapport,
     Controls, ExtCtrls,
     Math,
     Classes, SysUtils;




(***********************************************************
 Obsolète

 A la place, on utilise une liste d'attente de raids dont les cibles
 sont choisis par l'utilisateur

 Peut-être, plus tard, faire en sorte qu'une algorithme ajoute lui-même
 des éléments dans cette liste

     *)

type
     TAttackAutomatique = class(TObject)
     private
        // Timer
        FTimer: TTimer;
        FInTimer: boolean;
        FIntervalEntreAttack: integer;       // en millisecondes

        // Liste des rapports déjà trié par ordre décroissant de ressource
        FRapportList: TCollectionRapportRecent;
        FRapportIndiceToAnalyse: integer;

        // Joueur et planète actuelle
        FCurrentPlayer: TPlayerGestion;
        FCurrPlayerCurrPlanete : TPlaneteInfo;

        ///////////////////////////////////
        // Configuration

        // Nombre de GT min pour attaquer
        FConfMinGT: integer;

        // Définit si on doit utiliser de préférence les PT
        FConfUsePTIfPossible: boolean;

        // Défint la planète de départ pour lancer les attaques
        FConfPlaneteDepart: TPlanetLocation;


        function GetNextCibleToAttack: PRapportHead;
        procedure OnTimer(Sender: TObject);
        procedure Reset;
     public
        property CurrPlayer : TPlayerGestion           read FCurrentPlayer write FCurrentPlayer;
        procedure SetListRapport(ListRapport: TCollectionRapportRecent);

        
        procedure StartAttackAuto;
        procedure StopAttackAuto;

        constructor Create;
        destructor Destroy; override;
     end;


implementation


procedure TAttackAutomatique.OnTimer(Sender: TObject);
label lFin;
var Cible: PRapportHead;
begin
    if FInTimer then exit;
    FInTimer := true;

    Cible := GetNextCibleToAttack;

    if Cible = nil then begin
       // Plus de cible qui rentrent dans les critères
       goto lFin;
    end;

    


lFin:
    FInTimer := false;
end;



function TAttackAutomatique.GetNextCibleToAttack: PRapportHead;
var i: integer;
    TotalRessource: integer;
    NbGT : integer;
    NbPT : integer;
begin
    Result := nil;

    if FRapportList.Count >= FRapportIndiceToAnalyse then exit;

    for i := FRapportIndiceToAnalyse to FRapportList.Count - 1 do begin
        Result := FRapportList.Items[i];

        // Fait la somme des ressources à prendre
        TotalRessource := Result.Ressource.Metal + Result.Ressource.Cristal + Result.Ressource.Deuterium;
        NbGT := Ceil((TotalRessource div 2) / 24500);
        NbPT := Ceil((TotalRessource div 2) / 5000) + 1;

        if NbGT < FConfMinGT then begin
           // Pas assez de ressource
           // la liste étant trier par ordre décroissant, inutile de traiter les autres éléments
           FRapportIndiceToAnalyse := FRapportList.Count;
           Result := nil;
           exit;
        end;

        // Assez de GT pour cette cible
        // Vérifie la défense et la flotte
        if (Result.DefenseScore < 5) and (Result.NbFlotte = 0) then begin
            // aucune défense (ou petite défense) et aucune flotte
            // On peut attaquer sans problème
            sfcFlagsAdd(FLAG_ATTACKAUTO_DEJAATTACKE, Result.Flags);
            exit;

        end;

    end;


    Result := nil;

end;

procedure TAttackAutomatique.Reset;
begin
    FTimer.Interval := 0;
    FInTimer        := false;
    FRapportIndiceToAnalyse := 0;
end;

constructor TAttackAutomatique.Create;
begin
    inherited Create;

    FTimer := TTimer.Create(nil);
    FIntervalEntreAttack  := 5000;

    FConfMinGT           := 3;
    FConfUsePTIfPossible := true;

    Reset;
end;

destructor TAttackAutomatique.Destroy;
begin

    FTimer.Free;

    inherited Destroy;
end;

procedure TAttackAutomatique.SetListRapport(ListRapport: TCollectionRapportRecent);
var i: integer;
    pe : PRapportHead;
begin
    FRapportList := ListRapport;

    if FRapportList.Count = 0 then exit;

    for i := 0 to FRapportList.Count - 1 do begin
       pe := FRapportList.Items[i];

       sfcFlagsDel(FLAG_ATTACKAUTO_DEJAATTACKE, pe.Flags);
    end;

end;

procedure TAttackAutomatique.StartAttackAuto;
begin

end;

procedure TAttackAutomatique.StopAttackAuto;
begin

end;

function GetNextCibleToAttack(FromPlanete: TPlanetLocation; RapportList: TCollectionRapportRecent; VaisseauxList: TCollectionVaisseauSelInfos): TPlanetLocation;
begin
     // function mbtGetDistance(Depart, Cible: TPlanetLocation): integer;

end;

end.
